package com.kgc.scd.service.impl;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.kgc.scd.bean.ShopCart;
import com.kgc.scd.bean.ShopGoods;
import com.kgc.scd.mapper.ShopCartMapper;
import com.kgc.scd.mapper.ShopGoodsMapper;
import com.kgc.scd.service.ShopCartService;
import com.kgc.scd.util.PageSupport;
import com.kgc.scd.util.SnowUtil;
import com.kgc.scd.vo.ShopCartVO;
import com.kgc.scd.vo.ShopGoodsVO;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

/**
 * Created On : 2022/11/16 0016.
 * <p>
 * Author : shiguangchuan
 * <p>
 * Description: 购物车业务实现类
 */
@Service
public class ShopCartServiceImpl implements ShopCartService {

    @Autowired
    private ShopGoodsMapper shopGoodsMapper;

    @Autowired
    private ShopCartMapper shopCartMapper;

    @Autowired
    private SnowUtil snowUtil;

    @Override
    public boolean insertShopCart(String userId, String goodsId, Integer cartNumber) {

        // mybatis-plus,创建一个查询对象
        QueryWrapper<ShopCart> cartQueryWrapper = new QueryWrapper<>();
        // 用and拼接多条件查询语句
        cartQueryWrapper.and(wrapper -> wrapper.eq("goods_id",goodsId).eq("user_id",userId));

        // 根据商品id获取商品的详情
        ShopGoods shopGoods = shopGoodsMapper.selectById(goodsId);

        // 判断添加到购物车的数量是否超出商品现有库存量,是否在合理限购范围内
        if (cartNumber > shopGoods.getGoodsNumber() || cartNumber < 1 || cartNumber > 50){
            // 如果购买的商品数量在限制额度内，但是超出了该商品的现有库存，回应添加失败，商品库存不足
            return false;
        }

        // 封装购物车信息实体，方便插入数据
        ShopCart shopCart = new ShopCart();
        shopCart.setId(snowUtil.snowId());
        shopCart.setUserId(userId);
        shopCart.setGoodsId(goodsId);
        shopCart.setRetailPrice(shopGoods.getRetailPrice());
        shopCart.setSumPrice(shopGoods.getRetailPrice() * cartNumber);
        shopCart.setCartNumber(cartNumber);
        shopCart.setCartStatus(0);
        shopCart.setCreationTime(new Date());

        // 购物车中没有该商品信息的情况，直接添加到购物车
        if (shopCartMapper.selectCount(cartQueryWrapper) == 0){
            // 将需要添加到购物车的信息插入进数据库
            shopCartMapper.insert(shopCart);

            return true;
        }

        // 如果购物车本身就存在该商品的情况下，就直接在其基础上增加商品数量
        ShopCart shopCartOld = shopCartMapper.selectOne(cartQueryWrapper);
        // 增加数量时需要判断，万一增加后的数量超过库存或最大限制额度的话得，得考虑数量限制
        // 如果商品库存小于最大购买额度，那么就以库存量当做最大购买量
        if (shopGoods.getGoodsNumber() < 50) {
            shopCartOld.setCartNumber((shopCartOld.getCartNumber() + cartNumber) > shopGoods.getGoodsNumber() ? shopGoods.getGoodsNumber() : (shopCartOld.getCartNumber() + cartNumber));
        }else {
            // 否则商品库存量大于限制额度的，那么以限制额度作为最大购买量
            shopCartOld.setCartNumber(Math.min((shopCartOld.getCartNumber() + cartNumber), 50));
        }

        // 修改购物车中单品总价
        shopCartOld.setSumPrice(shopCartOld.getCartNumber() * shopGoods.getRetailPrice());
        shopCartOld.setCreationTime(new Date());

        // 修改已存在购物车中的数量和商品总价信息
        shopCartMapper.update(shopCartOld,cartQueryWrapper);

        return true;
    }

    @Override
    public boolean updateShopCartNumber(String userId, String goodsId, Integer cartNumber) {

        // mybatis-plus,创建一个查询对象
        QueryWrapper<ShopCart> cartQueryWrapper = new QueryWrapper<>();
        // 用and拼接多条件查询语句
        cartQueryWrapper.and(wrapper -> wrapper.eq("goods_id",goodsId).eq("user_id",userId));

        // 如果购物车中本身就不存在该商品，该接口不提供数量修改的任何操作
        if (shopCartMapper.selectCount(cartQueryWrapper) == 0){
            return false;
        }

        // 根据商品id获取商品的详情
        ShopGoods shopGoods = shopGoodsMapper.selectById(goodsId);

        // 判断添加到购物车的数量是否超出商品现有库存量,是否在合理限购范围内
        if (cartNumber > shopGoods.getGoodsNumber() || cartNumber < 1 || cartNumber > 50){
            // 如果购买的商品数量在限制额度内，但是超出了该商品的现有库存，回应添加失败，商品库存不足
            return false;
        }

        // 如果购物车本身就存在该商品的情况下，就直接在其基础上增加商品数量
        ShopCart shopCartOld = shopCartMapper.selectOne(cartQueryWrapper);

        shopCartOld.setCartNumber(cartNumber);
        shopCartOld.setSumPrice(shopCartOld.getRetailPrice() * cartNumber);
        shopCartOld.setCreationTime(new Date());

        // 修改购物车的单品数量，并调整其单品总价
        shopCartMapper.update(shopCartOld,cartQueryWrapper);

        return true;
    }

    @Override
    public boolean deleteOneOrMoreCartByIds(List<String> ids) {

        // 遍历需要删除的购物车id，并达到批量删除的操作
        ids.forEach(id -> {

            shopCartMapper.deleteById(id);

        });

        return true;
    }

    @Override
    public boolean deleteAllCartByUserId(String userId) {

        // mybatis-plus,创建一个查询对象
        QueryWrapper<ShopCart> cartQueryWrapper = new QueryWrapper<>();
        // 添加条件语句
        cartQueryWrapper.eq("user_id",userId);

        // 如果用户购物车列表中有商品信息可以进行批量删除
        if (shopCartMapper.selectCount(cartQueryWrapper) > 0) {
            // 该用户存在商品信息，可以执行全部删除
            shopCartMapper.delete(cartQueryWrapper);

            return true;
        }

        // 没有商品信息不执行删除，返回清空购物车失败
        return false;
    }

    @Override
    @Async
    public void updateCartStatus(String id) {

        // mybatis-plus,创建一个查询对象
        QueryWrapper<ShopCart> cartQueryWrapper = new QueryWrapper<>();
        // 添加条件语句
        cartQueryWrapper.eq("id",id);

        // 查询出该id对应的购物车信息
        ShopCart shopCart = shopCartMapper.selectById(id);

        // 修改购物车信息的勾选状态
        if (shopCart.getCartStatus() == 0){
            shopCart.setCartStatus(1);
            shopCartMapper.update(shopCart,cartQueryWrapper);
            return;
        }

        shopCart.setCartStatus(0);
        shopCartMapper.update(shopCart,cartQueryWrapper);

    }

    @Override
    @Async
    public void updateAllCartStatus(String userId,Integer allStatus) {

        // mybatis-plus,创建一个查询对象
        QueryWrapper<ShopCart> cartQueryWrapper1 = new QueryWrapper<>();
        // 添加条件语句
        cartQueryWrapper1.eq("user_id",userId);

        // 查询用户购物车中的所有商品列表
        List<ShopCart> shopCartList = shopCartMapper.selectList(cartQueryWrapper1);

        shopCartList.forEach(shopCart -> {

            // mybatis-plus,创建一个查询对象
            QueryWrapper<ShopCart> cartQueryWrapper2 = new QueryWrapper<>();
            // 用and拼接多条件查询语句
            cartQueryWrapper2.and(wrapper -> wrapper.eq("goods_id",shopCart.getGoodsId()).eq("user_id",userId));

            // 如果传入的值为1，代表需要全部勾上
            if (allStatus == 1){
                shopCart.setCartStatus(1);
                shopCartMapper.update(shopCart,cartQueryWrapper2);
            }else {
                // 如果传入的值为0，代表要全部取消
                shopCart.setCartStatus(0);
                shopCartMapper.update(shopCart, cartQueryWrapper2);
            }
        });


    }

    @Override
    public Double getSumCart(String userId) {

        // mybatis-plus,创建一个查询对象
        QueryWrapper<ShopCart> sumCartQueryWrapper = new QueryWrapper<>();
        // 通过拼接条件，实现sum函数的使用
        sumCartQueryWrapper.select("IFNULL(sum(sum_price),0) as sumAll")
                .and(wrapper -> wrapper.eq("user_id",userId).eq("cart_status",1));

        // 实体属性中添加一个数据库不存在的字段属性 sumAll 用来接收查询到的总和数据
        ShopCart shopCart = shopCartMapper.selectOne(sumCartQueryWrapper);

        // 返回查询到的总和
        return shopCart.getSumAll();
    }

    @Override
    public PageSupport<List<ShopCartVO>> getCartList(Integer pageNo, Integer pageSize, String userId) {

        // 创建统一返回分页对象
        PageSupport<List<ShopCartVO>> pageSupport = new PageSupport<>();

        // mybatis-plus,创建一个查询对象
        QueryWrapper<ShopCart> cartQueryWrapper = new QueryWrapper<>();
        // 添加在历史足迹列表中查询该用户的所有足迹信息
        cartQueryWrapper.eq("user_id",userId);
        cartQueryWrapper.orderByDesc("creation_time");

        // 创建分页对象
        // 页码和条数的处理都由内在源码自动处理，不需要自己再手动处理
        Page<ShopCart> shopCartPage = new Page<>(pageNo,pageSize);

        // 查询购物车列表
        Page<ShopCart> cartResultPage = shopCartMapper.selectPage(shopCartPage,cartQueryWrapper);

        // 添加分页的页码数据
        pageSupport.setPageNo(pageNo);
        pageSupport.setPageSize(pageSize);
        pageSupport.setTotalPage((int) cartResultPage.getPages());
        pageSupport.setTotalCount((int) cartResultPage.getTotal());

        // 遍历信息，存入map中
        List<ShopCartVO> ShopCartVOList = cartResultPage.getRecords().stream().map(shopCart -> {

            // 创建购物车VO实体对象
            ShopCartVO shopCartVO = new ShopCartVO();
            // 拷贝实体属性
            BeanUtils.copyProperties(shopCart,shopCartVO);

            // 获取到该购物车商品的商品id
            String goodsId = shopCart.getGoodsId();

            // 通过商品id查询商品的基本信息
            ShopGoods shopGoods = shopGoodsMapper.selectById(goodsId);

            // 创建商品VO实体对象
            ShopGoodsVO shopGoodsVO = new ShopGoodsVO();
            // 拷贝实体属性
            BeanUtils.copyProperties(shopGoods,shopGoodsVO);
            shopGoodsVO.setGoodsNumber(shopGoods.getGoodsNumber() == 0 ? "已售罄" : "可购买");

            // 将该购物车商品的详情插入其中
            shopCartVO.setShopGoodsVO(shopGoodsVO);

            return shopCartVO;

        }).collect(Collectors.toList());

        // 添加分页数据
        pageSupport.setPageData(Collections.singleton(ShopCartVOList));

        // 返回分页数据
        return pageSupport;
    }

    @Override
    public Long getCartCount(String userId) {

        // mybatis-plus,创建一个查询对象
        QueryWrapper<ShopCart> cartQueryWrapper = new QueryWrapper<>();
        // 添加在历史足迹列表中查询该用户的所有足迹信息
        cartQueryWrapper.eq("user_id",userId);

        return shopCartMapper.selectCount(cartQueryWrapper);

    }


    /*@Override
    public PageSupport<Map<String, ShopGoodsVO>> getCartList(Integer pageNo, Integer pageSize, String userId) {

        // 创建统一返回分页对象
        PageSupport<Map<String, ShopGoodsVO>> pageSupport = new PageSupport<>();

        // mybatis-plus,创建一个查询对象
        QueryWrapper<ShopCart> cartQueryWrapper = new QueryWrapper<>();
        // 添加在历史足迹列表中查询该用户的所有足迹信息
        cartQueryWrapper.eq("user_id",userId);
        cartQueryWrapper.orderByDesc("creation_time");

        // 创建分页对象
        // 页码和条数的处理都由内在源码自动处理，不需要自己再手动处理
        Page<ShopCart> shopCartPage = new Page<>(pageNo,pageSize);

        // 查询购物车列表
        Page<ShopCart> cartResultPage = shopCartMapper.selectPage(shopCartPage,cartQueryWrapper);

        // 添加分页的页码数据
        pageSupport.setPageNo(pageNo);
        pageSupport.setPageSize(pageSize);
        pageSupport.setTotalPage((int) cartResultPage.getPages());
        pageSupport.setTotalCount((int) cartResultPage.getTotal());

        // 新建Map存入购物车信息及商品信息
        Map<String, ShopGoodsVO> map = new HashMap<>();

        // 遍历信息，存入map中
        cartResultPage.getRecords().forEach(shopCart -> {

            // 创建购物车VO实体对象
            ShopCartVO shopCartVO = new ShopCartVO();
            // 拷贝实体属性
            BeanUtils.copyProperties(shopCart,shopCartVO);
            shopCartVO.setCartStatus(shopCart.getCartStatus() == 0 ? "未被选取" : "已被勾选");

            // 获取到该购物车商品的商品id
            String goodsId = shopCart.getGoodsId();

            // 通过商品id查询商品的基本信息
            ShopGoods shopGoods = shopGoodsMapper.selectById(goodsId);

            // 创建商品VO实体对象
            ShopGoodsVO shopGoodsVO = new ShopGoodsVO();
            // 拷贝实体属性
            BeanUtils.copyProperties(shopGoods,shopGoodsVO);
            shopGoodsVO.setGoodsNumber(shopGoods.getGoodsNumber() == 0 ? "已售罄" : "可购买");

            map.put(JSON.toJSONString(shopCartVO),shopGoodsVO);

        });

        // 添加分页数据
        pageSupport.setPageData((Collection<Map<String, ShopGoodsVO>>) map);

        // 返回分页数据
        return pageSupport;
    }*/

    /*@Override
    public Map<String, ShopGoodsVO> getCartList(Integer pageNo, Integer pageSize, String userId) {

        // mybatis-plus,创建一个查询对象
        QueryWrapper<ShopCart> cartQueryWrapper = new QueryWrapper<>();
        // 添加在历史足迹列表中查询该用户的所有足迹信息
        cartQueryWrapper.eq("user_id",userId);
        cartQueryWrapper.orderByDesc("creation_time");

        // 创建分页对象
        // 页码和条数的处理都由内在源码自动处理，不需要自己再手动处理
        Page<ShopCart> shopCartPage = new Page<>(pageNo,pageSize);

        // 查询购物车列表
        Page<ShopCart> cartResultPage = shopCartMapper.selectPage(shopCartPage,cartQueryWrapper);

        // 新建Map存入购物车信息及商品信息
        Map<String,ShopGoodsVO> map = new HashMap<>();

        // 遍历信息，存入map中
        cartResultPage.getRecords().forEach(shopCart -> {

            // 创建购物车VO实体对象
            ShopCartVO shopCartVO = new ShopCartVO();
            // 拷贝实体属性
            BeanUtils.copyProperties(shopCart,shopCartVO);
            shopCartVO.setCartStatus(shopCart.getCartStatus() == 0 ? "未被选取" : "已被勾选");

            // 获取到该购物车商品的商品id
            String goodsId = shopCart.getGoodsId();

            // 通过商品id查询商品的基本信息
            ShopGoods shopGoods = shopGoodsMapper.selectById(goodsId);

            // 创建商品VO实体对象
            ShopGoodsVO shopGoodsVO = new ShopGoodsVO();
            // 拷贝实体属性
            BeanUtils.copyProperties(shopGoods,shopGoodsVO);
            shopGoodsVO.setGoodsNumber(shopGoods.getGoodsNumber() == 0 ? "已售罄" : "可购买");

            map.put(JSON.toJSONString(shopCartVO),shopGoodsVO);

        });

        // 返回数据
        return map;
    }*/
}
